home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d16 / winsrc.arc / WINDOS.C < prev    next >
C/C++ Source or Header  |  1991-06-16  |  29KB  |  975 lines
  1. /*
  2.     Routines which simulate DOS functions in the existing
  3.     Fractint for DOS
  4. */
  5.  
  6. #include "windows.h"
  7. #include "fractint.h"
  8. #include "winfract.h"
  9. #include <time.h>
  10. #include <stdio.h>
  11.  
  12. int save_system;           /* tag identifying Fractint for Windows */
  13. int save_release;          /* tag identifying version number */
  14. int win_release = 1600;     /* tag identifying version number */
  15. char win_comment[] =       /* "About..." comment */ 
  16.     {" "};                 /*  publicly-released version */
  17. /*  {"Test Version - Not for Release"};   /* interim test versions */
  18.  
  19. extern BOOL bTrack;                  /* TRUE if user is selecting a region */
  20. extern BOOL zoomflag;                /* TRUE is a zoom-box selected */
  21.  
  22. extern HWND hwnd;                    /* handle to main window */
  23.  
  24. extern int xdots, ydots, colors, maxiter;
  25. extern int xposition, yposition, win_xoffset, win_yoffset, xpagesize, ypagesize;
  26. extern int win_xdots, win_ydots;
  27.  
  28. extern int last_written_y;           /* last line written */
  29. extern int screen_to_be_cleared;     /* clear screen flag */
  30.  
  31. extern int time_to_act;              /* time to take some action? */
  32. extern int time_to_restart;          /* time to restart?  */
  33. extern int time_to_quit;             /* time to quit? */
  34. extern int time_to_reinit;           /* time to reinitialize? */
  35. extern int time_to_load;             /* time to load? (DECODE) */
  36. extern int time_to_save;             /* time to save? (ENCODE) */
  37. extern int time_to_print;            /* time to print? (PRINTER) */
  38. extern int time_to_cycle;            /* time to begin color-cycling? */
  39.  
  40. extern unsigned char dacbox[256][3];
  41.  
  42. extern BOOL win_systempaletteused;    /* flag system palette set */
  43.  
  44. extern unsigned char far temp_array[];   /* temporary spot for Encoder rtns */
  45.  
  46. extern HANDLE hpixels;            /* handle to the DIB pixels */
  47. extern unsigned char huge *pixels;   /* the device-independent bitmap pixels */
  48. int pixels_per_byte;                 /* pixels/byte in the pixmap */
  49. long pixels_per_bytem1;              /* pixels / byte - 1 (for ANDing) */
  50. int pixelshift_per_byte;             /* 0, 1, 2, or 3 */
  51. int bytes_per_pixelline;             /* pixels/line / pixels/byte */
  52. long win_bitmapsize;                 /* bitmap size, in bytes */
  53.  
  54. extern int win_overlay3d;
  55. extern int win_display3d;
  56.  
  57. /****************************************************************************
  58.  
  59.     FUNCTION: keypressed(), getakey()
  60.  
  61.     PURPOSE:
  62.          keypressed()
  63.               Checks for, and processes, messages.
  64.               Returns -1 if it's time to wrap up and go home.
  65.               Returns 0 otherwise.
  66.         getakey()
  67.               same, but doesn't return until it's time to.
  68.  
  69.  
  70. ****************************************************************************/
  71.  
  72. BOOL dont_wait_for_a_key = TRUE;
  73.  
  74. #ifdef __BORLANDC__
  75.    int LPTNumber;
  76.    int stackavail() { return(10240 + (signed int)_SP); }
  77. #else
  78.    int _FAR_ _cdecl printf() {}
  79.    int _bios_serialcom(){}
  80. #endif
  81.  
  82.  
  83.  
  84.  
  85. int getakey()
  86. {
  87. int i;
  88.  
  89. dont_wait_for_a_key = FALSE;
  90. i = keypressed();
  91. dont_wait_for_a_key = TRUE;
  92. zoomflag = FALSE;
  93. return(i);
  94.  
  95. }
  96.  
  97. int keypressed()
  98. {
  99. MSG msg;
  100.  
  101. if (dont_wait_for_a_key)
  102.     if (PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE) == 0) {
  103.         time_to_act = time_to_reinit+time_to_restart+time_to_quit+
  104.             time_to_load+time_to_save+time_to_print+time_to_cycle;
  105.         /* bail out if nothing is happening */
  106.         return(time_to_act);
  107.         }
  108.  
  109. while (GetMessage(&msg, NULL, NULL, NULL)) {
  110.  
  111.     TranslateMessage(&msg);
  112.     DispatchMessage(&msg); 
  113.  
  114.     CheckMathTools();
  115.     if (!bTrack) {                /* don't do this if mouse-button is down */
  116.         time_to_act = time_to_reinit+time_to_restart+time_to_quit+
  117.             time_to_load+time_to_save+time_to_print+time_to_cycle;
  118.         if (dont_wait_for_a_key || time_to_act)
  119.             return(time_to_act);
  120.         }
  121.  
  122.     }
  123.  
  124. if (!dont_wait_for_a_key)
  125.     time_to_quit = 1;
  126.         
  127.     /* bail out if nothing is happening */
  128.     time_to_act = time_to_reinit+time_to_restart+time_to_quit+
  129.         time_to_load+time_to_save+time_to_print+time_to_cycle;
  130.     return(time_to_act);
  131.  
  132. }
  133.  
  134. /****************************************************************************
  135.  
  136.     FUNCTION: putcolor(int x, int y, int color), getcolor(int x, int y)
  137.  
  138.     PURPOSE:
  139.         putcolor:
  140.            sets the "color" value of the pixel at location x,y
  141.            (actually, a palette value)
  142.         getcolor:
  143.            returns the "color" value of the pixel at location x,y
  144.            (actually, a palette value)
  145.  
  146. ****************************************************************************/
  147.  
  148. extern int debug_fastupdate;
  149.  
  150. time_t last_time;
  151. time_t update_time;
  152. long minimum_update;
  153. long pixelsout;
  154. int top_changed, bottom_changed;
  155.  
  156. /* Made global, MCP 6-16-91 */
  157. unsigned char win_andmask[8];
  158. unsigned char win_notmask[8];
  159. unsigned char win_bitshift[8];
  160.  
  161. void putcolor(int x, int y, int color)
  162. {
  163. RECT tempRect;                   /* temporary rectangle structure */
  164. long i;
  165. int j, tempcolor, temp_top_changed, temp_bottom_changed;
  166. time_t this_time;
  167.  
  168. last_written_y = y;
  169. if (y < top_changed) top_changed = y;
  170. if (y > bottom_changed) bottom_changed = y;
  171.  
  172. i = win_ydots-1-y;
  173. i = (i * win_xdots) + x;
  174.  
  175. if (x >= 0 && x < xdots && y >= 0 && y < ydots) {
  176.     if (pixelshift_per_byte == 0) {
  177.           pixels[i] = color % colors;
  178.           }
  179.      else {
  180.           unsigned int j;
  181.           j = i & pixels_per_bytem1;
  182.           i = i >> pixelshift_per_byte;
  183.           pixels[i] = (pixels[i] & win_notmask[j]) +
  184.               (((unsigned char)(color % colors)) << win_bitshift[j]);
  185.           }
  186.  
  187.      /* check the time every nnn pixels */
  188.      if (debug_fastupdate || ++pixelsout > 100) {
  189.           pixelsout = 0;
  190.           this_time = time(NULL);
  191.           /* time to update the screen? */
  192.           if (debug_fastupdate || (this_time - last_time) > update_time ||
  193.               (minimum_update*(this_time-last_time)) > (bottom_changed-top_changed)) {
  194.               temp_top_changed = top_changed - win_yoffset;
  195.               temp_bottom_changed = bottom_changed - win_yoffset;
  196.               if (!(temp_top_changed >= ypagesize || temp_bottom_changed < 0)) {
  197.                   if (temp_top_changed < 0) temp_top_changed = 0;
  198.                   if (temp_bottom_changed < 0) temp_bottom_changed = 0;
  199.                   tempRect.top = temp_top_changed;
  200.                   tempRect.bottom = temp_bottom_changed+1;
  201.                   tempRect.left = 0;
  202.                   tempRect.right = xdots;
  203.                   InvalidateRect(hwnd, &tempRect, FALSE);
  204.                   keypressed();    /* force a look-see at the screen */
  205.                   }
  206.               last_time = this_time;
  207.               top_changed = win_ydots;
  208.               bottom_changed = 0;
  209.               }
  210.           }
  211.      }
  212.  
  213. }
  214.  
  215. int getcolor(int x, int y)
  216. {
  217. long i;
  218.  
  219. i = win_ydots-1-y;
  220. i = (i * win_xdots) + x;
  221.  
  222. if (x >= 0 && x < xdots && y >= 0 && y < ydots) {
  223.     if (pixelshift_per_byte == 0) {
  224.           return(pixels[i]);
  225.           }
  226.      else {
  227.           unsigned int j;
  228.           j = i & pixels_per_bytem1;
  229.           i = i >> pixelshift_per_byte;
  230.           return((int)((pixels[i] & win_andmask[j]) >> win_bitshift[j]));
  231.           }
  232.      }
  233. else
  234.      return(0);
  235. }
  236.  
  237. int put_line(int rownum, int leftpt, int rightpt, unsigned char *localvalues)
  238. {
  239. int i, len;
  240. long startloc;
  241.  
  242. len = rightpt - leftpt;
  243. if (rightpt >= xdots) len = xdots - 1 - leftpt;
  244. startloc = win_ydots-1-rownum;
  245. startloc = (startloc * win_xdots) + leftpt;
  246.  
  247. if (rownum < 0 || rownum >= ydots || leftpt < 0) {
  248.     return(0);
  249.     }
  250.  
  251. if (pixelshift_per_byte == 0) {
  252.     for (i = 0; i <= len; i++)
  253.         pixels[startloc+i] = localvalues[i];
  254.     }
  255. else {
  256.     unsigned int j;
  257.     long k;
  258.     for (i = 0; i <= len; i++) {
  259.         k = startloc + i;
  260.         j = k & pixels_per_bytem1;
  261.         k = k >> pixelshift_per_byte;
  262.         pixels[k] = (pixels[k] & win_notmask[j]) +
  263.             (((unsigned char)(localvalues[i] % colors)) << win_bitshift[j]);
  264.         }
  265.     }
  266. pixelsout += len;
  267. putcolor(leftpt, rownum, localvalues[0]);
  268. }
  269.  
  270. int get_line(int rownum, int leftpt, int rightpt, unsigned char *localvalues)
  271. {
  272. int i, len;
  273. long startloc;
  274.  
  275. len = rightpt - leftpt;
  276. if (rightpt >= xdots) len = xdots - 1 - leftpt;
  277. startloc = win_ydots-1-rownum;
  278. startloc = (startloc * win_xdots) + leftpt;
  279.  
  280. if (rownum < 0 || rownum >= ydots || leftpt < 0 || rightpt >= xdots) {
  281.     for (i = 0; i <= len; i++)
  282.         localvalues[i] = 0;
  283.     return(0);
  284.     }
  285.  
  286. if (pixelshift_per_byte == 0) {
  287.     for (i = 0; i <= len; i++)
  288.         localvalues[i] = pixels[startloc+i];
  289.     }
  290. else {
  291.     unsigned int j;
  292.     long k;
  293.     for (i = 0; i <= len; i++) {
  294.         k = startloc + i;
  295.         j = k & pixels_per_bytem1;
  296.         k = k >> pixelshift_per_byte;
  297.         localvalues[i] = (pixels[k] & win_andmask[j]) >> win_bitshift[j];
  298.         }
  299.     }
  300. }
  301.  
  302. extern int rowcount;
  303.  
  304. int out_line(unsigned char *localvalues, int numberofdots)
  305. {
  306.     put_line(rowcount++, 0, numberofdots, localvalues);
  307. }
  308.  
  309. extern LPBITMAPINFO pDibInfo;        /* pointer to the DIB info */
  310.  
  311. int clear_screen(int forceclear)
  312. {
  313. long numdots;
  314. int i;
  315.  
  316. win_xdots = (xdots+3) & 0xfffc;
  317. win_ydots = ydots;
  318. pixelshift_per_byte = 0;
  319. pixels_per_byte   = 1;
  320. pixels_per_bytem1 = 0;
  321. if (colors == 16) {
  322.     win_xdots = (xdots+7) & 0xfff8;
  323.     pixelshift_per_byte = 1;
  324.     pixels_per_byte = 2;
  325.     pixels_per_bytem1 = 1;
  326.     win_andmask[0] = 0xf0;  win_notmask[0] = 0x0f; win_bitshift[0] = 4;
  327.     win_andmask[1] = 0x0f;  win_notmask[1] = 0xf0; win_bitshift[1] = 0;
  328.     }
  329. if (colors == 2) {
  330.     win_xdots = (xdots+31) & 0xffe0;
  331.     pixelshift_per_byte = 3;
  332.     pixels_per_byte = 8;
  333.     pixels_per_bytem1 = 7;
  334.     win_andmask[0] = 0x80;  win_notmask[0] = 0x7f; win_bitshift[0] = 7;
  335.     for (i = 1; i < 8; i++) {
  336.         win_andmask[i] = win_andmask[i-1] >> 1;
  337.         win_notmask[i] = (win_notmask[i-1] >> 1) + 0x80;
  338.         win_bitshift[i] = win_bitshift[i-1] - 1;
  339.         }
  340.     }
  341.  
  342. numdots = (long)win_xdots * (long) win_ydots;
  343. update_time = 2;
  344. if (numdots > 200000L) update_time = 4;
  345. if (numdots > 400000L) update_time = 8;
  346. last_time = time(NULL) - update_time + 1;
  347. minimum_update = 7500/xdots;    /* assume 75,000 dots/sec drawing speed */
  348.  
  349. last_written_y = -1;
  350. pixelsout = 0;
  351. top_changed = win_ydots;
  352. bottom_changed = 0;
  353.  
  354. bytes_per_pixelline = win_xdots >> pixelshift_per_byte;
  355.  
  356. /* Create the Device-independent Bitmap entries */
  357. pDibInfo->bmiHeader.biWidth  = win_xdots;
  358. pDibInfo->bmiHeader.biHeight = win_ydots;
  359. pDibInfo->bmiHeader.biSizeImage = (DWORD)bytes_per_pixelline * win_ydots;
  360. pDibInfo->bmiHeader.biBitCount = 8 / pixels_per_byte;
  361.  
  362. /* hard to believe, but this is the fast way to clear the pixel map */
  363. if (hpixels) {
  364.      GlobalUnlock(hpixels);
  365.      GlobalFree(hpixels);
  366.      }
  367.  
  368. win_bitmapsize = (numdots >> pixelshift_per_byte)+1;
  369.  
  370. if (!(hpixels = GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, win_bitmapsize)))
  371.      return(0);
  372. if (!(pixels = (char huge *)GlobalLock(hpixels))) {
  373.      GlobalFree(hpixels);
  374.      return(0);
  375.      }
  376.  
  377. /* adjust the colors for B&W or default */
  378. if (colors == 2) {
  379.     dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
  380.     dacbox[1][0] = dacbox[1][1] = dacbox[1][2] = 63;
  381.     spindac(0,1);
  382.     }
  383. else
  384.     restoredac();   /* color palette */
  385.  
  386. screen_to_be_cleared = 1;
  387. InvalidateRect(hwnd, NULL, TRUE);
  388.  
  389. if (forceclear)
  390.     keypressed();        /* force a look-see at the screen */
  391.  
  392. return(1);
  393. }
  394.  
  395. int flush_screen()
  396. {
  397.  
  398. last_written_y = 0;
  399.  
  400. InvalidateRect(hwnd, NULL, FALSE);
  401.  
  402. }
  403.  
  404. /****************************************************************************
  405.  
  406.     FUNCTION: buzzer(int buzzertype)
  407.  
  408.     PURPOSE:
  409.               make some sort of sound (hey, we do what we can)
  410.  
  411. ****************************************************************************/
  412.  
  413. void buzzer(int i)
  414. {
  415.  
  416. MessageBeep(0);
  417.  
  418. }
  419.  
  420. /****************************************************************************
  421.  
  422.     FUNCTION: unsigned char far * farmemalloc(long bytecount)
  423.               void farmemfree(unsigned char * bytepointer)
  424.     PURPOSE:
  425.               allocate and free memory in a manner consistent with
  426.               Fractint for DOS
  427.  
  428. ****************************************************************************/
  429.  
  430. #define MAXFARMEMALLOCS  20        /* max active farmemallocs */
  431. int   farmemallocinit = 0;              /* any memory been allocated yet?   */
  432. HANDLE farmemallochandles[MAXFARMEMALLOCS];            /* handles  */
  433. void far *farmemallocpointers[MAXFARMEMALLOCS];    /* pointers */
  434.  
  435. unsigned char far * farmemalloc(long bytecount)
  436. {
  437. int i;
  438. HANDLE temphandle;
  439. unsigned char far *temppointer;
  440.  
  441. if (!farmemallocinit) {        /* never been here yet - initialize */
  442.     farmemallocinit = 1;
  443.     for (i = 0; i < MAXFARMEMALLOCS; i++) {
  444.         farmemallochandles[i] = (HANDLE)0;
  445.         farmemallocpointers[i] = NULL;
  446.         }
  447.     }
  448.  
  449. for (i = 0; i < MAXFARMEMALLOCS; i++)  /* look for a free handle */
  450.     if (farmemallochandles[i] == (HANDLE)0) break;
  451.  
  452. if (i == MAXFARMEMALLOCS)       /* uh-oh - no more handles */
  453.    return(NULL);        /* can't get far memory this way */
  454.  
  455. if (!(temphandle = GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, bytecount)))
  456.      return(NULL);        /* can't allocate the memory */
  457. if (!(temppointer = (unsigned char far *)GlobalLock(temphandle))) {
  458.      GlobalFree(temphandle);
  459.      return(NULL);        /* ?? can't lock the memory ?? */
  460.      }
  461.  
  462. farmemallochandles[i] =  temphandle;
  463. farmemallocpointers[i] = temppointer;
  464. return(temppointer);
  465. }
  466.  
  467. void farmemfree(void far *bytepointer)
  468. {
  469. int i;
  470. HANDLE temphandle;
  471. unsigned char far *temppointer;
  472.  
  473. if (bytepointer == (void far *)NULL) return;
  474.  
  475. for (i = 0; i < MAXFARMEMALLOCS; i++)    /* search for a matching pointer */
  476.     if (farmemallocpointers[i] == bytepointer)
  477.          break;
  478. if (i < MAXFARMEMALLOCS) {        /* got one */
  479.     GlobalUnlock(farmemallochandles[i]);
  480.     GlobalFree(farmemallochandles[i]);
  481.     farmemallochandles[i] = (HANDLE)0;
  482.     }
  483.  
  484. }
  485.  
  486. debugmessage(char *msg1, char *msg2)
  487. {
  488. MessageBox (
  489.     GetFocus(),
  490.     msg2,
  491.     msg1,
  492.     MB_ICONASTERISK | MB_OK);
  493.  
  494. }
  495.  
  496. texttempmsg(char *msg1)
  497. {
  498. MessageBox (
  499.     GetFocus(),
  500.     msg1,
  501.     "Encoder",
  502.     MB_ICONASTERISK | MB_OK);
  503. }
  504.  
  505. stopmsg(int flags, unsigned char far *msg1)
  506. {
  507. int result;
  508.  
  509. if (! (flags & 4)) MessageBeep(0);
  510.  
  511. result = IDOK;
  512.  
  513. if (!(flags & 2))
  514.     MessageBox (
  515.         GetFocus(),
  516.         msg1,
  517.         "Fractint for Windows",
  518.         MB_ICONASTERISK | MB_OK);
  519. else 
  520.     result = MessageBox (
  521.         GetFocus(),
  522.         msg1,
  523.         "Fractint for Windows",
  524.         MB_ICONQUESTION | MB_OKCANCEL);
  525.  
  526. if (result == 0 || result == IDOK || result == IDYES)
  527.     return(0);
  528. else
  529.     return(-1);
  530. }
  531.  
  532. extern char readname[];
  533. extern int fileydots, filexdots, filecolors;
  534. extern int     iNumColors;    /* Number of colors supported by device           */
  535.  
  536. win_load()
  537. {
  538. int i;
  539. char temp[80];
  540.  
  541. time_to_load = 0;
  542.  
  543.     start_wait();
  544.     if ((i = read_overlay()) >= 0 && (!win_display3d || 
  545.         xdots < filexdots || ydots < fileydots)) {
  546.         if (win_display3d) stopmsg(0,
  547.             "3D and Overlay3D file image sizes must be\nat least as large as the display image.\nAltering your display image to match the file.");
  548.         xdots = filexdots;
  549.         ydots = fileydots;
  550.         colors = filecolors;
  551.         if (colors > 16) colors = 256;
  552.         if (colors >  2 && colors < 16) colors = 16;
  553.         if (xdots < 50) xdots = 50;
  554.         if (xdots > 2048) xdots = 2048;
  555.         if (ydots < 50) ydots = 50;
  556.         if (ydots > 2048) ydots = 2048;
  557.         set_win_offset();
  558.         clear_screen(0);
  559.         }
  560.     end_wait();
  561.     return(i);
  562. }
  563.  
  564. win_save()
  565. {
  566.     start_wait();
  567.     time_to_save = 0;
  568.     save_system = 1;
  569.     save_release = win_release;
  570.     savetodisk(readname);
  571.     end_wait();
  572. }
  573.  
  574. extern HDC PASCAL GetPrinterDC(void);
  575.  
  576. win_print()
  577. {
  578. int Return;
  579. int display_xpixperinch, display_ypixperinch;
  580. int printer_xdots, printer_ydots, printer_colors;
  581. int printer_xpixperinch, printer_ypixperinch;
  582. int printer_xmill, printer_ymill;
  583. int printer_xacross, printer_yacross;
  584. int printer_bandable;
  585. long firstpixel;
  586. float daspect, paspect;
  587. HDC printerDC, displayDC;
  588. WORD printer_usage;
  589. RECT printerRect;
  590. int more;
  591.  
  592. time_to_print = 0;
  593.  
  594. displayDC = GetDC(NULL);
  595. display_xpixperinch  =  GetDeviceCaps(displayDC,LOGPIXELSX);
  596. display_ypixperinch  =  GetDeviceCaps(displayDC,LOGPIXELSY);
  597. ReleaseDC(NULL,displayDC);
  598. daspect = ((float)xdots / (float)display_xpixperinch) /
  599.     ((float)ydots / (float)display_ypixperinch);
  600.  
  601. if ((printerDC = GetPrinterDC())) {
  602.     start_wait();
  603.     printer_xpixperinch  =  GetDeviceCaps(printerDC,LOGPIXELSX);
  604.     printer_ypixperinch  =  GetDeviceCaps(printerDC,LOGPIXELSY);
  605.     printer_xmill  =  GetDeviceCaps(printerDC,HORZSIZE);
  606.     printer_ymill  =  GetDeviceCaps(printerDC,VERTSIZE);
  607.     printer_xdots  =  GetDeviceCaps(printerDC,HORZRES);
  608.     printer_ydots  =  GetDeviceCaps(printerDC,VERTRES);
  609.     printer_colors =  GetDeviceCaps(printerDC,NUMCOLORS);
  610.     printer_bandable =  GetDeviceCaps(printerDC,RASTERCAPS) & RC_BANDING;
  611.     printer_bandable = 0;
  612.     paspect = ((float)printer_xdots / (float) printer_xmill) /
  613.         ((float)printer_ydots / (float) printer_ymill);
  614.     printer_xacross = printer_xdots;
  615.     printer_yacross = (float)printer_xdots / daspect / paspect;
  616.     if (printer_yacross > printer_ydots) {
  617.         printer_xacross = (float)printer_xacross * (float) printer_ydots /
  618.             (float)printer_yacross;
  619.         if (printer_xacross > printer_xdots)
  620.             printer_xacross = printer_xdots;
  621.         printer_yacross = printer_ydots;
  622.         }
  623.     firstpixel = win_ydots - ydots;
  624.     firstpixel = firstpixel * bytes_per_pixelline;
  625.     printer_usage = DIB_PAL_COLORS;
  626.     if (printer_colors <= 2) {
  627.         mono_dib_palette();      /* B&W stripes for B&W printers */
  628.         printer_usage = DIB_RGB_COLORS;
  629.         }
  630.     Return = Escape (printerDC, STARTDOC, 17, (LPSTR)"Fractint Printout", NULL);
  631.     if (Return <= 0) goto oops;
  632.     if (printer_bandable)
  633.         Escape(printerDC, NEXTBAND, 0, NULL, (LPSTR) &printerRect);
  634.     more = 1;
  635.     while (more) {
  636.         if (printer_bandable)
  637.             DPtoLP(printerDC, (LPPOINT) &printerRect, 2);
  638.         Return = StretchDIBits(printerDC,
  639.             0, 0,
  640.             printer_xacross, printer_yacross,
  641.             0, 0,
  642.             xdots, ydots,
  643.             &pixels[firstpixel], (LPBITMAPINFO)pDibInfo,
  644.             printer_usage, SRCCOPY);
  645.         if (Return <= 0) goto oops;
  646.         more = 0;
  647.         if (printer_bandable) {
  648.             Escape(printerDC, NEXTBAND, 0, NULL, (LPSTR) &printerRect);
  649.             more = IsRectEmpty(&printerRect);
  650.             }
  651.         }
  652.     Return = Escape(printerDC, NEWFRAME, 0, NULL, NULL);
  653.     if (Return <= 0) goto oops;
  654. oops: Escape(printerDC, ENDDOC, 0, NULL, NULL);
  655.     DeleteDC(printerDC);
  656.     default_dib_palette();   /* replace the palette */
  657.     end_wait();
  658.     if (Return < 0) stopmsg(0,
  659.         "File Print failed\nYou probably ran out of memory\nSorry...");
  660.     }
  661. else
  662.     stopmsg(0,"?? Can't find the printer!! ???");
  663. }
  664.  
  665. extern int win_cycledir, win_cyclerand, win_cyclefreq;
  666.  
  667. extern HANDLE  hPal;       /* Palette Handle */
  668. extern LPLOGPALETTE pLogPal;  /* pointer to the application's logical palette */
  669. extern unsigned char far win_dacbox[256][3];
  670. #define PALETTESIZE 256               /* dull-normal VGA                    */
  671.  
  672. static int win_fsteps[] = {54, 24, 8};
  673.  
  674. int win_animate_flag = 0;
  675. int win_syscolorindex[21];
  676. DWORD win_syscolorold[21];
  677. DWORD win_syscolornew[21];
  678.  
  679. extern int debugflag;
  680.  
  681. win_cycle()
  682. {
  683. int istep, jstep, fstep, step, oldstep, last, next, maxreg;
  684. int incr, random, fromred, fromblue, fromgreen, tored, toblue, togreen;
  685. HDC hDC;                      /* handle to device context           */
  686.  
  687. fstep = 1;                              /* randomization frequency      */
  688. oldstep = 1;                /* single-step            */
  689. step = 256;                /* single-step            */
  690. incr = 999;                /* ready to randomize        */
  691. maxreg = 256;                /* maximum register to rotate   */
  692. last = maxreg-1;            /* last box that was filled    */
  693. next = 1;                /* next box to be filled    */
  694. if (win_cycledir < 0) {
  695.     last = 1;
  696.     next = maxreg;
  697.     }
  698. srand((unsigned)time(NULL));        /* randomize things        */
  699.  
  700. hDC = GetDC(GetFocus());
  701.  
  702. win_animate_flag = 1;
  703. SetPaletteEntries(hPal, 0, pLogPal->palNumEntries, pLogPal->palPalEntry);
  704. SelectPalette (hDC, hPal, 1);
  705.  
  706. if ((iNumColors == 16 || debugflag == 1000) && !win_systempaletteused) {
  707.     int i;
  708.     DWORD white, black;
  709.     win_systempaletteused = TRUE;
  710.     white = 0xffffff00;
  711.     black = 0;
  712.     for (i = 0; i <= COLOR_ENDCOLORS; i++) {
  713.         win_syscolorindex[i] = i;
  714.         win_syscolorold[i] = GetSysColor(i);
  715.         win_syscolornew[i] = black;
  716.         }
  717.     win_syscolornew[COLOR_BTNTEXT] = white;
  718.     win_syscolornew[COLOR_CAPTIONTEXT] = white;
  719.     win_syscolornew[COLOR_GRAYTEXT] = white;
  720.     win_syscolornew[COLOR_HIGHLIGHTTEXT] = white;
  721.     win_syscolornew[COLOR_MENUTEXT] = white;
  722.     win_syscolornew[COLOR_WINDOWTEXT] = white;
  723.     win_syscolornew[COLOR_WINDOWFRAME] = white;
  724.     win_syscolornew[COLOR_INACTIVECAPTION] = white;
  725.     win_syscolornew[COLOR_INACTIVEBORDER] = white;
  726.     SetSysColors(COLOR_ENDCOLORS,win_syscolorindex,win_syscolornew);
  727.     SetSystemPaletteUse(hDC,SYSPAL_NOSTATIC);
  728.     UnrealizeObject(hPal);
  729.     }
  730.  
  731. while (time_to_cycle) {
  732.     if (win_cyclerand) {
  733.         for (istep = 0; istep < step; istep++) {
  734.             jstep = next + (istep * win_cycledir);
  735.             if (jstep <=      0) jstep += maxreg-1;
  736.             if (jstep >= maxreg) jstep -= maxreg-1;
  737.             if (++incr > fstep) {    /* time to randomize    */
  738.                 incr = 1;
  739.                 fstep = ((win_fsteps[win_cyclefreq]*
  740.                     (rand() >> 8)) >> 6) + 1;
  741.                 fromred   = dacbox[last][0];
  742.                 fromgreen = dacbox[last][1];
  743.                 fromblue  = dacbox[last][2];
  744.                 tored      = rand() >> 9;
  745.                 togreen   = rand() >> 9;
  746.                 toblue      = rand() >> 9;
  747.                 }
  748.             dacbox[jstep][0] = fromred   + (((tored   - fromred  )*incr)/fstep);
  749.             dacbox[jstep][1] = fromgreen + (((togreen - fromgreen)*incr)/fstep);
  750.             dacbox[jstep][2] = fromblue  + (((toblue  - fromblue )*incr)/fstep);
  751.             }
  752.         }
  753.         if (step >= 256) step = oldstep;
  754.  
  755.     spindac(win_cycledir,step);
  756.     AnimatePalette(hPal, 0, pLogPal->palNumEntries, pLogPal->palPalEntry);
  757.     RealizePalette(hDC); 
  758.     keypressed();
  759.     if (win_cyclerand == 2) {
  760.         win_cyclerand = 1;
  761.         step = 256;
  762.         }
  763.     }
  764.  
  765. win_animate_flag = 0;
  766. ReleaseDC(GetFocus(),hDC);
  767.  
  768. }
  769.  
  770. /* cursor routines */
  771.  
  772. extern HANDLE hSaveCursor;             /* the original cursor value */
  773. extern HANDLE hHourGlass;              /* the hourglass cursor value */
  774.  
  775. start_wait()
  776. {
  777.    hSaveCursor = SetCursor(hHourGlass);
  778. /* keypressed();   just to give messages, like cursor-changes, a chance */
  779. }
  780.  
  781. end_wait()
  782. {
  783.    SetCursor(hSaveCursor);
  784. /* keypressed();   just to give messages, like cursor-changes, a chance */
  785. }
  786.  
  787. /* video-mode routines */
  788.  
  789. extern int    viewwindow;        /* 0 for full screen, 1 for window */
  790. extern float  viewreduction;        /* window auto-sizing */
  791. extern float  finalaspectratio;     /* for view shape and rotation */
  792. extern int    viewxdots,viewydots;    /* explicit view sizing */
  793. extern int    fileydots, filexdots, filecolors;
  794. extern float  fileaspectratio;
  795. extern int    skipxdots,skipydots;    /* for decoder, when reducing image */
  796.  
  797. int get_video_mode(struct fractal_info *info)
  798. {
  799.    viewwindow = viewxdots = viewydots = 0;
  800.    fileaspectratio = .75;
  801.    skipxdots = skipydots = 0;
  802.    return(0);
  803. }
  804.  
  805.  
  806. void spindac(int direction, int step)
  807. {
  808. int i, j, k;
  809.  
  810. for (k = 0; k < step; k++) {
  811.     if (direction > 0) {
  812.         for (j = 0; j < 3; j++) {
  813.             for (i = 255; i >= 1; i--)
  814.                 dacbox[i+1][j] = dacbox[i][j];
  815.             dacbox[1][j] = dacbox[256][j];
  816.             }
  817.         }
  818.     if (direction < 0) {
  819.         for (j = 0; j < 3; j++) {
  820.             dacbox[256][j] = dacbox[1][j];
  821.             for (i = 1; i < 256; i++)
  822.                 dacbox[i][j] = dacbox[i+1][j];
  823.             }
  824.         }
  825.     }
  826.  
  827.     /* fill in intensities for all palette entry colors */
  828.     for (i = 0; i < 256; i++) {
  829.         pLogPal->palPalEntry[i].peRed   = ((BYTE)dacbox[i][0]) << 2;
  830.         pLogPal->palPalEntry[i].peGreen = ((BYTE)dacbox[i][1]) << 2;
  831.         pLogPal->palPalEntry[i].peBlue  = ((BYTE)dacbox[i][2]) << 2;
  832.         pLogPal->palPalEntry[i].peFlags = PC_RESERVED;
  833.         }
  834.  
  835.     if (!win_animate_flag) {
  836.         HDC hDC;
  837.         hDC = GetDC(GetFocus());
  838.         SetPaletteEntries(hPal, 0, pLogPal->palNumEntries, pLogPal->palPalEntry);
  839.         SelectPalette (hDC, hPal, 1);
  840.         RealizePalette(hDC); 
  841.         ReleaseDC(GetFocus(),hDC);
  842.         }
  843. }
  844.  
  845. restoredac()
  846. {
  847. int iLoop;
  848. int j;
  849.  
  850.     /* fill in intensities for all palette entry colors */
  851.     for (iLoop = 0; iLoop < PALETTESIZE; iLoop++) 
  852.         for (j = 0; j < 3; j++)
  853.             dacbox[iLoop][j] = win_dacbox[iLoop][j];
  854.     spindac(0,1);
  855. }
  856.  
  857. int ValidateLuts( char * fn )
  858. {
  859. FILE * f;
  860. unsigned    r, g, b, index;
  861. unsigned char    line[101];
  862. unsigned char    temp[81];
  863.     strcpy (temp,fn);
  864.     if (strchr(temp,'.') == NULL) /* Did name have an extension? */
  865.         strcat(temp,".map");  /* No? Then add .map */
  866.     findpath( temp, line);          /* search the dos path */
  867.     f = fopen( line, "r" );
  868.     if (f == NULL)
  869.         return 1;
  870.     for( index = 0; index < 256; index++ ) {
  871.         if (fgets(line,100,f) == NULL)
  872.             break;
  873.         sscanf( line, "%d %d %d", &r, &g, &b );
  874.         /** load global dac values **/
  875.         dacbox[index][0] = r >> 2;    /* maps default to 8 bits */
  876.         dacbox[index][1] = g >> 2;    /* DAC wants 6 bits */
  877.         dacbox[index][2] = b >> 2;
  878.     }
  879.     fclose( f );
  880.     return 0;
  881. }
  882.  
  883. int win_thinking = 0;
  884.  
  885. int thinking(int waiting, char *dummy)
  886. {
  887. if (waiting && ! win_thinking) {
  888.     win_thinking = 1;
  889.     start_wait();
  890.     }
  891. if (!waiting)
  892.     end_wait();
  893. return(keypressed());
  894. }
  895.  
  896. int far_strlen(char far *string) {
  897. int i;
  898. for (i = 0; ; i++)
  899.     if (string[i] == 0)
  900.         return(i);
  901. }
  902.  
  903. int far_strnicmp(char far *string1, char far *string2, int maxlen) {
  904. int i;
  905. unsigned char j, k;
  906. for (i = 0;i < maxlen ; i++) {
  907.     j = string1[i];
  908.     k = string2[i];
  909.     if (j >= 'a' && j <= 'z') j -= ('a' - 'A');
  910.     if (k >= 'a' && k <= 'z') k -= ('a' - 'A');
  911.     if (j-k != 0)
  912.         return(j-k);
  913.     }
  914. return(0);
  915. }
  916.  
  917. int far_memcpy(void far *string1, void far *string2, int maxlen) {
  918. int i;
  919. for (i = 0;i < maxlen ; i++)
  920.     ((char far *)string1)[i] = ((char far *)string2)[i];
  921. }
  922.  
  923. /* fake/not-yet-implemented subroutines */
  924.  
  925. int getakeynohelp() {return(getakey());}
  926. int kbhit() { return(keypressed()); }
  927. int getch() {return(13);}
  928.  
  929. void farmessage(unsigned char far *foo) {}
  930. void setvideomode(int foo1, int foo2, int foo3, int foo4) {}
  931. int fromvideotable() {}
  932. int setforgraphics() {}
  933. int setfortext() {}
  934. int movecursor() {}
  935. int home() {}
  936.  
  937. int intro_overlay() {}
  938. int help_overlay() {}
  939. int prompts_overlay() {}
  940. int rotate_overlay() {}
  941. int printer_overlay() {}
  942. int miscovl_overlay() {}
  943. int pot_startdisk() {}
  944. int SetTgaColors() {}
  945. int startdisk() {}
  946. int enddisk() {}
  947. int readdisk() {}
  948. int writedisk() {}
  949. int nosnd(){}
  950. int snd(){}
  951. int targa_startdisk(){}
  952. int targa_writedisk(){}
  953. int SetColorPaletteName() {}
  954. int get_3d_params() { return(0);}
  955. int findfont() {return(0);}
  956. int readticker(){return(0);}
  957. int EndTGA(){}
  958.  
  959. int setattr(){}
  960. int helptitle(){}
  961. int stackscreen(){}
  962. int unstackscreen(){}
  963. void putstring(int foo1, int foo2, int foo3, unsigned char far *foo4){}
  964. int putstringcenter(int foo1, int foo2, int foo3, int foo4, char far *foo5){}
  965. int dvid_status(){}
  966. int goodbye(){}
  967. int tovideotable(){}
  968.  
  969. void load_mat(){}
  970. void mult_vec_iit(){}
  971. int check_vidmode_keyname(){return(0);}
  972. void print_document(){}
  973. void makedoc_msg_func(){}
  974.  
  975.